home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 February: Technology Seed / Mac Tech Seed Feb '97.toast / OpenDoc 1.2b2c1 / Implementation / Messaging / OSL / CntxtOSL.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-13  |  12.8 KB  |  410 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        CntxtOSL.c
  3.  
  4.     Contains:    New functions specific to this Context version of the OSL
  5.  
  6.     Owned by:    Nick Pilch
  7.  
  8.     Copyright:    © 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <2>      12/13/96    JP        1607652: Added & disabled debugging code
  13.         <11>     8/29/95    jpa        DescPtr --> AEDesc* for Univ Hdrs 2.1.
  14.                                     [1279173]
  15.         <10>     6/27/95    NP        1262792: new version of OSLObjectInit
  16.          <9>     6/23/95    NP        1195474: Make Resolve reentrant.
  17.          <8>      5/3/95    NP        1211084: Remove 5$
  18.          <7>     4/25/95    NP        1186795, 1237220, 1240571: Fixed whose
  19.                                     clauses by allowing swapping in count proc.
  20.          <6>     2/22/95    eeh        1222904: fix use of SetCurrentContext
  21.          <5>      2/8/95    NP        1218550: Don't allocate OSLContexts
  22.                                     dynamically.
  23.          <4>     1/22/95    NP        Create dummy pascal routines for other
  24.                                     exportable routines in the OSL.
  25.          <3>    11/15/94    NP        1196322-made functions non-pascal. Added
  26.                                     glue code.
  27.          <2>     8/19/94    NP        1181622: Ownership fix.
  28.          <9>      2/7/94    NP        Tiger Team doings.
  29.          <8>    12/20/93    NP        Changed CountProc to be able to switch
  30.                                     contexts.
  31.          <7>    10/22/93    NP        Added OSLCallObjectAccessor.
  32.          <6>    10/18/93    NP        Support for the rest of the callback
  33.                                     functions.
  34.          <5>    10/11/93    NP        Implemented new count and compare callback
  35.                                     dispatch routines.
  36.          <4>     9/24/93    JA        Minor syntactic tweaks for THINK C++.
  37.          <3>     8/18/93    NP        Mods for new context scheme.
  38.          <2>     8/16/93    NP        Implementing.
  39.          <1>     8/16/93    NP        first checked in
  40.  
  41.     To Do:
  42. */
  43.  
  44. #ifndef _CNTXTOSL_
  45. #include "CntxtOSL.h"
  46. #endif
  47.  
  48. #ifndef __AEOBJECTS__
  49. #include <AEObjects.h>
  50. #endif
  51.  
  52. #ifndef _OSLPRIV_
  53. #include "OSLPriv.h"
  54. #endif
  55.  
  56. #ifndef _OSLTOKEN_
  57. #include "OSLToken.h"
  58. #endif
  59.  
  60. // set to 0 for no debugging & 1 for debugging
  61. #define LOGGING 0
  62. //debugging stuff
  63. // Declare somPrintf w/o having to include all those SOM headers:
  64. #if PRAGMA_IMPORT_SUPPORTED
  65. #pragma import on
  66. #endif
  67. int somPrintf (const char * fmt, ...);        // From <som.xh>
  68. #if PRAGMA_IMPORT_SUPPORTED
  69. #pragma import off
  70. #endif
  71. //
  72. #define LOG        if(!LOGGING) ; else somPrintf
  73.  
  74. #pragma segment CntxtOSL
  75.  
  76. OSErr CREATEOBJSPECIFIER(DescType desiredClass, AEDesc *theContainer, DescType keyForm, AEDesc *keyData, Boolean disposeInputs, AEDesc *objSpecifier);
  77. OSErr CREATERANGEDESCRIPTOR(AEDesc *rangeStart, AEDesc *rangeStop, Boolean disposeInputs, AEDesc *theDescriptor);
  78. OSErr CREATELOGICALDESCRIPTOR(AEDescList *theLogicalTerms, DescType theLogicOperator, Boolean disposeInputs, AEDesc *theDescriptor);
  79. OSErr CREATEOFFSETDESCRIPTOR(long theOffset, AEDesc *theDescriptor);
  80. OSErr CREATECOMPDESCRIPTOR(DescType comparisonOperator, AEDesc *operand1, AEDesc *operand2, Boolean disposeInputs, AEDesc *theDescriptor);
  81.  
  82. #pragma lib_export on
  83.  
  84. //------------------------------------------------------------------------------
  85. // OSLObjectInit
  86. //------------------------------------------------------------------------------
  87.  
  88. OSErr OSLObjectInit( OSLContext* context ) 
  89. {
  90.     return iAEObjectInit(context);
  91. }
  92.  
  93. //------------------------------------------------------------------------------
  94. // OSLResolve
  95. //------------------------------------------------------------------------------
  96.  
  97. OSErr OSLResolve(const AEDesc* objectSpecifier, OSLToken* theToken,
  98.                         OSLContext* startingContext)
  99. {
  100.     return iAEResolve(*objectSpecifier, theToken, startingContext);
  101. }
  102.  
  103. //------------------------------------------------------------------------------
  104. // OSLDisposeToken
  105. //------------------------------------------------------------------------------
  106.  
  107. OSErr OSLDisposeToken(OSLToken* theToken)
  108. {
  109.     return iAEDisposeToken(theToken);
  110. }
  111.  
  112. //------------------------------------------------------------------------------
  113. // OSLCallObjectAccessor
  114. //------------------------------------------------------------------------------
  115.  
  116. OSErr OSLCallObjectAccessor(DescType        desiredClass,
  117.                                     const AEDesc    *containerToken,
  118.                                     DescType        containerClass,
  119.                                     DescType        keyForm,
  120.                                     const AEDesc    *keyData,
  121.                                     AEDesc            *token )
  122. {
  123.     return iCallAccessor(desiredClass, *containerToken, containerClass,
  124.                             keyForm, *keyData, token);
  125. }
  126.  
  127. #pragma lib_export off
  128.  
  129. //------------------------------------------------------------------------------
  130. // GetAppDoesFlags
  131. //------------------------------------------------------------------------------
  132.  
  133. OSErr GetAppDoesFlags(OSLContext* context, short* appDoesFlags)
  134. {
  135.     CallbackCallerProc    dispatchProc;
  136.  
  137.     dispatchProc = (*context->getCallerProc)(kCallbackFlagsGetter);
  138.     *appDoesFlags = (*(CallbackFlagsGetter)dispatchProc)(context->refCon);
  139.     return noErr;
  140. }
  141.  
  142. //------------------------------------------------------------------------------
  143. // NewCallCountProc
  144. //------------------------------------------------------------------------------
  145.  
  146. OSErr NewCallCountProc(DescType        desiredType,
  147.                         DescType    containerClass,
  148.                         OSLToken    container,
  149.                         long*        result)
  150. {
  151.     CallbackCallerProc    dispatchProc;
  152.     OSLContext            context;
  153.     OSErr                error;
  154. //    OSLContext            afterContext;
  155.  
  156.     error = GetCurrentContext(&context);
  157.     if (error)
  158.         return error;
  159.     dispatchProc = (*context.getCallerProc)(kCountProc);
  160.     error = (*(CountProcCaller)dispatchProc)(desiredType, containerClass,
  161.                                                 &container, result,
  162.                                                 context.refCon);
  163.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  164.     {
  165.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  166.         if (aGlobalRef)
  167.         {
  168.             OSLCountUPP aProcPtr = (*aGlobalRef)->countProcPtr ;
  169.             if (aProcPtr)
  170.                 error = CallOSLCountProc(aProcPtr, desiredType, containerClass,
  171.                                             container, result);
  172.         }
  173.     }
  174.     return error;
  175. #if 0
  176.     // CONTEXT CHANGED?
  177.     if (container.descriptorType == kSwitchDescType && (error == noErr))
  178.     {
  179.         // DISPOSE OLD CONTAINER TOKEN????
  180.         error = OSLGetTokenContext(&container, &afterContext);
  181.         if (error)
  182.             return error;
  183.         error = SetCurrentContext(&afterContext);
  184.         if (error)
  185.             return error;
  186.         // DISPOSE TOKEN???? PROBABLY.
  187.         MakeNullToken(&container);
  188.         containerClass = typeNull;
  189.         error = (*(CountProcCaller)dispatchProc)(desiredType, containerClass,
  190.                                                     &container, result,
  191.                                                     context.refCon);
  192.     }
  193. #endif /* 0 */
  194. }
  195.  
  196. //------------------------------------------------------------------------------
  197. // NewCallCompareProc
  198. //------------------------------------------------------------------------------
  199.  
  200. OSErr NewCallCompareProc(DescType            oper,
  201.                             OSLToken        obj1,
  202.                             OSLToken        obj2,
  203.                             Boolean*        result)
  204. {
  205.     CallbackCallerProc    dispatchProc;
  206.     OSLContext            context;
  207.     OSErr                error;
  208.  
  209.     error = GetCurrentContext(&context);
  210.     if (error)
  211.         return error;
  212.     dispatchProc = (*context.getCallerProc)(kCompareProc);
  213.     error =  (*(CompareProcCaller)dispatchProc)(oper, &obj1, &obj2, result,
  214.                                                 context.refCon);
  215.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  216.     {
  217.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  218.         if (aGlobalRef)
  219.         {
  220.             OSLCompareUPP aProcPtr = (*aGlobalRef)->compareProcPtr ;
  221.             if (aProcPtr)
  222.                 error = CallOSLCompareProc(aProcPtr, oper, obj1, obj2, result);
  223.         }
  224.     }
  225.     return error;
  226. }
  227.  
  228. //------------------------------------------------------------------------------
  229. // NewCallAdjustMarks
  230. //------------------------------------------------------------------------------
  231.  
  232. OSErr NewCallAdjustMarks(long newStart, long newStop, OSLToken markToken)
  233. {
  234.     CallbackCallerProc    dispatchProc;
  235.     OSLContext            context;
  236.     OSErr                error;
  237.  
  238.     error = GetCurrentContext(&context);
  239.     if (error)
  240.         return error;
  241.     dispatchProc = (*context.getCallerProc)(kAdjustMarksProc);
  242.     error = (*(AdjustMarksProcCaller)dispatchProc)(newStart, newStop,
  243.                                                     &markToken, context.refCon);
  244.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  245.     {
  246.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  247.         if (aGlobalRef)
  248.         {
  249.             OSLAdjustMarksUPP aProcPtr = (*aGlobalRef)->AdjustMarksProcPtr ;
  250.             if (aProcPtr)
  251.                 error = CallOSLAdjustMarksProc(aProcPtr, newStart, newStop,
  252.                                                 markToken);
  253.         }
  254.     }
  255.     return error;
  256. }
  257.  
  258. //------------------------------------------------------------------------------
  259. // NewCallMark
  260. //------------------------------------------------------------------------------
  261.  
  262. OSErr NewCallMark(OSLToken dToken, OSLToken  markToken, long n)
  263. {
  264.     CallbackCallerProc    dispatchProc;
  265.     OSLContext            context;
  266.     OSErr                error;
  267.  
  268.     error = GetCurrentContext(&context);
  269.     if (error)
  270.         return error;
  271.     dispatchProc = (*context.getCallerProc)(kMarkProc);
  272.     error = (*(MarkProcCaller)dispatchProc)(&dToken, &markToken, n,
  273.                                             context.refCon);
  274.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  275.     {
  276.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  277.         if (aGlobalRef)
  278.         {
  279.             OSLMarkUPP aProcPtr = (*aGlobalRef)->MarkProcPtr;
  280.             if (aProcPtr)
  281.                 error = CallOSLMarkProc(aProcPtr, dToken, markToken, n);
  282.         }
  283.     }
  284.     return error;
  285. }
  286.  
  287. //------------------------------------------------------------------------------
  288. // NewCallGetMarkToken
  289. //------------------------------------------------------------------------------
  290.  
  291. OSErr NewCallGetMarkToken(OSLToken dContainerToken, DescType containerClass,
  292.                             OSLToken *result)
  293. {
  294.     CallbackCallerProc    dispatchProc;
  295.     OSLContext            context;
  296.     OSErr                error;
  297.  
  298.     error = GetCurrentContext(&context);
  299.     if (error)
  300.         return error;
  301.     dispatchProc = (*context.getCallerProc)(kGetMarkTokenProc);
  302.     error = (*(GetMarkTokenProcCaller)dispatchProc)(&dContainerToken,
  303.                                                     containerClass,
  304.                                                     result,
  305.                                                     context.refCon);
  306.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  307.     {
  308.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  309.         if (aGlobalRef)
  310.         {
  311.             OSLGetMarkTokenUPP aProcPtr = (*aGlobalRef)->getMarkIDProcPtr;
  312.             if (aProcPtr)
  313.                 error = CallOSLGetMarkTokenProc(aProcPtr, dContainerToken,
  314.                                                 containerClass, result);
  315.         }
  316.     }
  317.     return error;
  318. }
  319.  
  320. //------------------------------------------------------------------------------
  321. // NewCallGetErrDesc
  322. //------------------------------------------------------------------------------
  323.  
  324. OSErr NewCallGetErrDesc(AEDesc* *appDescPtr)
  325. {
  326.     CallbackCallerProc    dispatchProc;
  327.     OSLContext            context;
  328.     OSErr                error;
  329.  
  330.     error = GetCurrentContext(&context);
  331.     if (error)
  332.         return error;
  333.     dispatchProc = (*context.getCallerProc)(kGetErrDescProc);
  334.     error = (*(GetErrDescProcCaller)dispatchProc)(appDescPtr, context.refCon);
  335.     if (error == errAEEventNotHandled || error == errAENotASpecialFunction)
  336.     {
  337.         GlobalRecHandle aGlobalRef = GetSysGlobal();
  338.         if (aGlobalRef)
  339.         {
  340.             OSLGetErrDescUPP aProcPtr = (*aGlobalRef)->TypeAsIndexProc;
  341.             if (aProcPtr)
  342.                 error = CallOSLGetErrDescProc(aProcPtr, appDescPtr);
  343.         }
  344.     }
  345.     return error;
  346. }
  347.  
  348. //------------------------------------------------------------------------------
  349. // NewCallDisposeToken
  350. //
  351. //    Code in the orginal OSL already handles calling through to the system
  352. //    handler, if any.
  353. //------------------------------------------------------------------------------
  354.  
  355. OSErr NewCallDisposeToken(OSLToken* theToken)
  356. {
  357.     CallbackCallerProc    dispatchProc;
  358.     OSLContext            context;
  359.     OSErr                error;
  360.  
  361.     error = GetCurrentContext(&context);
  362. //
  363.     LOG("-Disposing token with current OSL context: %8.8x\n", context.refCon);
  364. //
  365.     if (error)
  366.         return error;
  367.     dispatchProc = (*context.getCallerProc)(kDisposeTokenProc);
  368.     return (*(DisposeTokenProcCaller)dispatchProc)(theToken, context.refCon);
  369. }
  370.  
  371. //==============================================================================
  372. // Grunge for linker
  373. //
  374. //    We use the same export files for PowerPC and 68K. However, these routine
  375. //    really need to be upper case in the 68K case (because they are pascal), but
  376. //    mixed case in the PowerPC case. Therefore, we have both versions of the
  377. //    routines in both builds. In the PowerPC case, the upper case names are
  378. //    not exported. In the 68K case, the upper case are exported, but you get
  379. //    link warnings because there are two definitions of them. It's OK, both
  380. //    versions are semantically identical.
  381. //==============================================================================
  382.  
  383. #pragma lib_export on
  384.  
  385. OSErr CREATEOBJSPECIFIER(DescType desiredClass, AEDesc *theContainer, DescType keyForm, AEDesc *keyData, Boolean disposeInputs, AEDesc *objSpecifier)
  386. {
  387.     return CreateObjSpecifier(desiredClass, theContainer, keyForm, keyData, disposeInputs, objSpecifier);
  388. }
  389.  
  390. OSErr CREATERANGEDESCRIPTOR(AEDesc *rangeStart, AEDesc *rangeStop, Boolean disposeInputs, AEDesc *theDescriptor)
  391. {
  392.     return CreateRangeDescriptor(rangeStart, rangeStop, disposeInputs, theDescriptor);
  393. }
  394.  
  395. OSErr CREATELOGICALDESCRIPTOR(AEDescList *theLogicalTerms, DescType theLogicOperator, Boolean disposeInputs, AEDesc *theDescriptor)
  396. {
  397.     return CreateLogicalDescriptor(theLogicalTerms, theLogicOperator, disposeInputs, theDescriptor);
  398. }
  399.  
  400. OSErr CREATEOFFSETDESCRIPTOR(long theOffset, AEDesc *theDescriptor)
  401. {
  402.     return CreateOffsetDescriptor(theOffset, theDescriptor);
  403. }
  404.  
  405. OSErr CREATECOMPDESCRIPTOR(DescType comparisonOperator, AEDesc *operand1, AEDesc *operand2, Boolean disposeInputs, AEDesc *theDescriptor)
  406. {
  407.     return CreateCompDescriptor(comparisonOperator, operand1, operand2, disposeInputs, theDescriptor);
  408. }
  409.  
  410.